/**
 * 维度抽取
 * @param data
 * @param keyFiled
 * @param valueFiled
 */
export function dimensionExtraction(data, keyFiled) {
  const items = []
  for (const item in data) {
    const value = data[item][keyFiled]
    if (items.indexOf(value) === -1) {
      items.push(value)
    }
  }
  return items
}

/**
 * 时间抽取
 * @param data
 * @param keyFiled
 * @param valueFiled
 */
export function timeExtraction(data, keyFiled, format) {
  const items = []
  for (const item in data) {
    const value = data[item][keyFiled]
    if (items.indexOf(value) === -1) {
      items.push(value)
    }
  }
  return items
}

/**
 * 数据栅格化，并生成时间维度数据
 * @param   data                      数据
 * @param   analysisDimension         分析维度
 * @param   analysisDimensionField    分析维度字段
 * @param   timeDimensionField        时间维度字段
 * @param   timeDimensionFormat       时间维度格式
 * @param   timeDimensionStart        时间维度开始时间
 * @param   timeDimensionStop         时间维度结束时间
 * @param   timeDimensionInterval     时间维度间隔（单位：分钟）
 * @param   timeDimensionUom          时间维度单位（year/month/day/hour/minute/second）
 * @param   timeDimensionStep         时间维度步进位置（start、stop、middle）
 * @param   dataDimensionField        数据维度
 * @param   gridType                  栅格化方式
 *              summary                   求和
 *              average                   平均数
 *              count                     计数
 *              min                       最小值
 *              max                       最大值
 *              first                     首值
 *              last                      尾值
 *              list                      数组
 * @returns {*}
 */
export function initTimeSeries(data, analysisDimension, analysisDimensionField, timeDimensionField, timeDimensionFormat, timeDimensionStart, timeDimensionStop, timeDimensionInterval, timeDimensionUom, timeDimensionStep, dataDimensionField, gridType, time) {
  // 初始化Series
  // const series = {}
  const moment = require('moment')
  if (analysisDimension.length === 0 && analysisDimensionField === '') {
    // 时间维度处理，将data按时间排序
    data.sort(function(item1, item2) {
      return item1[timeDimensionField] > item2[timeDimensionField]
    })
    // 维度基础数据处理
    const timeData = []
    const interval = Number(timeDimensionInterval)

    // 生成时间区间
    const startTime = timeDimensionStart === '' ? moment(data[0][timeDimensionField]) : moment(timeDimensionStart)

    const stopTime = timeDimensionStop === '' ? moment(data[data.length - 1][timeDimensionField]) : moment(timeDimensionStop)
    // 设置取值，通过修改指向对象直接修改取值
    time['startTime'] = startTime.startOf(timeDimensionUom).toDate()
    time['stopTime'] = stopTime.endOf(timeDimensionUom).toDate()
    let t1 = startTime.startOf(timeDimensionUom).toDate()
    while (t1 < stopTime.endOf(timeDimensionUom).toDate()) {
      const t2 = moment(t1).add(interval, timeDimensionUom).toDate()
      timeData.push({ 'startTime': t1, 'stopTime': t2, data: [] })
      t1 = moment(t1).add(interval, timeDimensionUom).toDate()
    }

    // 按分析维度和时间维度生成基础数据项
    const items = {}
    items['数据'] = JSON.parse(JSON.stringify(timeData))
    // 按时间分配数据
    for (const i in data) {
      // 获取item
      const item = data[i]
      // 获取时间
      const time = item[timeDimensionField]
      // 计算时间间隔，确认所在数组
      items['数据'][moment(time).diff(startTime, timeDimensionUom) / interval].data.push(item[dataDimensionField])
    }
    // 生成 series
    for (const fItem in items) {
      for (const sItem in items[fItem]) {
        items[fItem][sItem] = [moment(items[fItem][sItem].startTime).format(timeDimensionFormat), summary(items[fItem][sItem].data)]
      }
    }
    return items
  } else {
    // 时间维度处理，将data按时间排序
    data.sort(function(item1, item2) {
      return item1[timeDimensionField] > item2[timeDimensionField]
    })
    // 维度基础数据处理
    const timeData = []
    const interval = Number(timeDimensionInterval)

    // 生成时间区间
    const startTime = timeDimensionStart === '' ? moment(data[0][timeDimensionField]) : moment(timeDimensionStart)
    const stopTime = timeDimensionStop === '' ? moment(data[data.length - 1][timeDimensionField]) : moment(timeDimensionStop)
      .toDate()

    // 设置取值，通过修改指向对象直接修改取值
    time['startTime'] = startTime.startOf(timeDimensionUom).toDate()

    time['stopTime'] = stopTime.endOf(timeDimensionUom).toDate()

    let t1 = startTime.startOf(timeDimensionUom).toDate()
    while (t1 < stopTime.endOf(timeDimensionUom).toDate()) {
      const t2 = moment(t1).add(interval, timeDimensionUom).toDate()
      timeData.push({ 'startTime': t1, 'stopTime': t2, data: [] })
      t1 = moment(t1).add(interval, timeDimensionUom).toDate()
    }

    // 按分析维度和时间维度生成基础数据项
    const items = {}
    for (const i in analysisDimension) {
      items[analysisDimension[i]] = JSON.parse(JSON.stringify(timeData))
    }
    // 按时间分配数据
    for (const i in data) {
      // 获取item
      const item = data[i]
      // 获取时间
      const time = item[timeDimensionField]
      // 计算时间间隔，确认所在数组
      items[item[analysisDimensionField]][moment(time).diff(startTime, timeDimensionUom) / interval].data.push(item[dataDimensionField])
    }
    // 生成 series
    for (const fItem in items) {
      for (const sItem in items[fItem]) {
        items[fItem][sItem] = [moment(items[fItem][sItem].startTime).format(timeDimensionFormat), summary(items[fItem][sItem].data)]
      }
    }
    return items
  }
}

/**
 * 数据栅格化，并生成单数据维度数据
 * @param   data                          数据
 * @param   firstAnalysisDimension        第一分析维度
 * @param   secondAnalysisDimension       第二分析维度
 * @param   firstAnalysisDimensionField   第一分析维度字段
 * @param   secondAnalysisDimensionField  第二分析维度字段
 * @param   dataDimensionField            数据维度字段
 * @param   gridType                      栅格化方式
 *              summary                       求和
 *              average                       平均数
 *              count                         计数
 *              min                           最小值
 *              max                           最大值
 *              first                         首值
 *              last                          尾值
 *              list                          数组
 * @returns {*}
 */
export function initSingleSeries(data, firstAnalysisDimension, secondAnalysisDimension, firstAnalysisDimensionField, secondAnalysisDimensionField, dataDimensionField, gridType) {
  // 初始化Series
  const series = {}

  // 如果只有一个分析维度
  if (secondAnalysisDimension.length === 0 && secondAnalysisDimensionField === '') {
    // 唯一维度，第二维度设置为单一项目
    secondAnalysisDimension = ['数据']
    // 初始化项目
    series['数据'] = []
    for (let i = 0; i < firstAnalysisDimension.length; i++) {
      series['数据'].push([])
    }
    // 数据分组
    for (const i in data) {
      // 获取item
      const item = data[i]
      // 获取序号
      const index = firstAnalysisDimension.indexOf(item[firstAnalysisDimensionField])
      // 添加到 list
      series['数据'][index].push(item[dataDimensionField])
    }
    // 数据处理
    for (const fItem in series) {
      for (const sItem in series[fItem]) {
        // 获取数据列表
        if (gridType === 'summary') {
          // 求和处理
          series[fItem][sItem] = summary(series[fItem][sItem])
        } else if (gridType === 'average') {
          // 平均值
          series[fItem][sItem] = average(series[fItem][sItem])
        } else if (gridType === 'count') {
          // 计数
          series[fItem][sItem] = count(series[fItem][sItem])
        } else if (gridType === 'min') {
          // 最小值
          series[fItem][sItem] = min(series[fItem][sItem])
        } else if (gridType === 'max') {
          // 最大值
          series[fItem][sItem] = max(series[fItem][sItem])
        } else if (gridType === 'frist') {
          // 首值
          series[fItem][sItem] = frist(series[fItem][sItem])
        } else if (gridType === 'last') {
          // 尾值
          series[fItem][sItem] = last(series[fItem][sItem])
        }
      }
    }
    return series
  } else {
    // 初始化项目
    for (const key in secondAnalysisDimension) {
      // 初始化维度
      series[secondAnalysisDimension[key]] = []
      for (let i = 0; i < firstAnalysisDimension.length; i++) {
        series[secondAnalysisDimension[key]].push([])
      }
    }
    // 数据分组
    for (const i in data) {
      // 获取item
      const item = data[i]
      // 获取序号
      const index = firstAnalysisDimension.indexOf(item[firstAnalysisDimensionField])
      if (secondAnalysisDimension.indexOf(item[secondAnalysisDimensionField]) !== -1) {
        // 对应位置
        series[item[secondAnalysisDimensionField]][index].push(item[dataDimensionField])
      }
    }
    // 数据处理
    for (const fItem in series) {
      for (const sItem in series[fItem]) {
        // 获取数据列表
        if (gridType === 'summary') {
          // 求和处理
          series[fItem][sItem] = summary(series[fItem][sItem])
        } else if (gridType === 'average') {
          // 平均值
          series[fItem][sItem] = average(series[fItem][sItem])
        } else if (gridType === 'count') {
          // 计数
          series[fItem][sItem] = count(series[fItem][sItem])
        } else if (gridType === 'min') {
          // 最小值
          series[fItem][sItem] = min(series[fItem][sItem])
        } else if (gridType === 'max') {
          // 最大值
          series[fItem][sItem] = max(series[fItem][sItem])
        } else if (gridType === 'frist') {
          // 首值
          series[fItem][sItem] = frist(series[fItem][sItem])
        } else if (gridType === 'last') {
          // 尾值
          series[fItem][sItem] = last(series[fItem][sItem])
        }
      }
    }
    return series
  }
}

/**
 * 数据栅格化，并生成单数据维度数据
 * @param   data                          数据
 * @param   firstAnalysisDimension        第一分析维度
 * @param   secondAnalysisDimension       第二分析维度
 * @param   firstAnalysisDimensionField   第一分析维度字段
 * @param   secondAnalysisDimensionField  第二分析维度字段
 * @param   firstDataDimensionField       第一数据维度字段
 * @param   firstGridType                 第一数据栅格化方式
 * @param   secondDataDimensionField      第二数据数据维度字段
 * @param   secondGridType                第二数据栅格化方式
 *              summary                       求和
 *              average                       平均数
 *              count                         计数
 *              min                           最小值
 *              max                           最大值
 *              mainMin                       主最小值
 *              mainMax                       主最大值
 *              first                         首值
 *              last                          尾值
 *              follow                        跟随
 *              list                          数组
 * @returns {*}
 */
export function initDoubleSeries(data, firstAnalysisDimension, secondAnalysisDimension, firstAnalysisDimensionField, secondAnalysisDimensionField, firstDataDimensionField, firstGridType, secondDataDimensionField, secondGridType) {
  // 初始化Series
  const series = {}

  if (firstAnalysisDimension.length === 0 && firstAnalysisDimensionField === '') {
    // 两个维度均设置为单一项目
    firstAnalysisDimension = ['数据']
    secondAnalysisDimension = ['数据']
    // 初始化项目
    for (const i in firstAnalysisDimension) {
      series[firstAnalysisDimension[i]] = []
    }
    // 数据分组
    for (const i in data) {
      // 获取item
      const item = data[i]
      // 添加到 list
      series['数据'].push([item[firstDataDimensionField], item[secondDataDimensionField]])
    }

    // 数据处理
    for (const fItem in series) {
      for (const sItem in series[fItem]) {
        if (firstGridType === 'list' || secondGridType === 'list') {
          // 如果有list，返回list
          series[fItem][sItem] = listArray(series[fItem][sItem])
        } else {
          // 如果不含list，处理数据
          series[fItem][sItem] = gridTypeArray(series[fItem][sItem], [firstGridType, secondGridType])
        }
      }
    }
    return series
  } else if (secondAnalysisDimension.length === 0 && secondAnalysisDimensionField === '') {
    // 唯一维度，第二维度设置为单一项目
    secondAnalysisDimension = ['数据']
    // 初始化项目
    for (const i in firstAnalysisDimension) {
      series[firstAnalysisDimension[i]] = []
    }
    // 数据分组
    for (const i in data) {
      // 获取item
      const item = data[i]
      // 获取序号
      const index = firstAnalysisDimension.indexOf(item[firstAnalysisDimensionField])
      // 添加到 list
      series[firstAnalysisDimension[index]].push([item[firstDataDimensionField], item[secondDataDimensionField]])
    }

    // 数据处理
    for (const fItem in series) {
      for (const sItem in series[fItem]) {
        if (firstGridType === 'list' || secondGridType === 'list') {
          // 如果有list，返回list
          series[fItem][sItem] = listArray(series[fItem][sItem])
        } else {
          // 如果不含list，处理数据
          series[fItem][sItem] = gridTypeArray(series[fItem][sItem], [firstGridType, secondGridType])
        }
      }
    }
    return series
  } else {
    // 双分析维度

    // 初始化项目
    for (const key in secondAnalysisDimension) {
      // 初始化维度
      series[secondAnalysisDimension[key]] = []
      for (let i = 0; i < firstAnalysisDimension.length; i++) {
        series[secondAnalysisDimension[key]].push([])
      }
    }
    // 数据分组
    for (const i in data) {
      // 获取item
      const item = data[i]
      // 获取序号
      const index = firstAnalysisDimension.indexOf(item[firstAnalysisDimensionField])
      if (secondAnalysisDimension.indexOf(item[secondAnalysisDimensionField]) !== -1) {
        // 对应位置
        series[item[secondAnalysisDimensionField]][index].push([item[firstDataDimensionField], item[secondDataDimensionField]])
      }
    }
    // 数据处理
    // for (const fItem in series) {
    //   // for (const sItem in series[fItem]) {

    //   // }
    // }
    return series
  }
}

// ===== ===== ===== =====  一维数组处理方式  ===== ===== ===== =====

/**
 * 求和
 * @param array
 */
function summary(array) {
  let reSum = 0
  if (array === null || array.length === 0) {
    return reSum
  }
  for (let i = 0; i < array.length; i++) {
    reSum += Number(array[i])
  }
  return reSum
}

/**
 * 求平均值
 * @param array
 */
function average(array) {
  let reSum = 0
  if (array === null || array.length === 0) {
    return reSum
  }
  for (let i = 0; i < array.length; i++) {
    reSum += Number(array[i])
  }
  return reSum / array.length
}

/**
 * 计数
 * @param array
 */
function count(array) {
  if (array === null || array.length === 0) {
    return 0
  }
  return array.length
}

/**
 * 最大值
 * @param array
 */
function max(array) {
  if (array === null || array.length === 0) {
    return 0
  }
  return Math.max(...array)
}

/**
 * 最小值
 * @param array
 */
function min(array) {
  if (array === null || array.length === 0) {
    return 0
  }
  return Math.min(...array)
}

/**
 * 最大值
 * @param array
 */
function frist(array) {
  if (array === null || array.length === 0) {
    return 0
  }
  return array[0]
}

/**
 * 最小值
 * @param array
 */
function last(array) {
  if (array === null || array.length === 0) {
    return 0
  }
  return array[array.length - 1]
}

// ===== ===== ===== =====  二维数组处理方式  ===== ===== ===== =====

/**
 * 数组
 * @param array
 */
function listArray(array) {
  return array
}

/**
 * 最小值
 * @param array
 */
function gridTypeArray(array, gridTypeArray) {
  // 处理 Main - follow 数据
  const follow = []
  const main = {}
  for (const i in gridTypeArray) {
    if (gridTypeArray.indexOf('main') !== -1) {
      main['index'] = i
      main['type'] = gridTypeArray[i]
    } else {
      follow.push(i)
    }
  }

  if (array === null || array.length === 0) {
    return 0
  }
  return array[array.length - 1]
}
